home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 June / EnigmA AMIGA RUN 08 (1996)(G.R. Edizioni)(IT)[!][issue 1996-06][EARSAN CD VII].iso / earcd / utilsys / rss14gmd.lha / RSys_1.4gmd / C / Monitor.c < prev    next >
C/C++ Source or Header  |  1996-05-04  |  15KB  |  609 lines
  1. /*
  2.    ***************************************************************************
  3.    *
  4.    * Datei:
  5.    *    RSysMonitor.c
  6.    *
  7.    * Inhalt:
  8.    *
  9.    *      --- Globale Routinen ---
  10.    *
  11.    *    void Monitor ( Objid *obj );
  12.    *
  13.    *      --- Lokale  Routinen ---
  14.    *
  15.    *    static int OpenMemMonitorWindow ( void );
  16.    *    static void SetListView ( void );
  17.    *    static void ConvertLine ( int type , int offset , char *memline , char *nodeline );
  18.    *    static void FreeDisplayMemory ( void );
  19.    *    static void ReInitDisplays ( void );
  20.    *    static int InitDisplays ( void );
  21.    *    static void ReadNextBlock ( void );
  22.    *    static void ReadPrevBlock ( void );
  23.    *    static int DisplayCYGadClicked ( void );
  24.    *    static int SaveCGadClicked ( void );
  25.    *    static int ASCIIGadClicked ( void );
  26.    *    static int SaveHexGadClicked ( void );
  27.    *    static int SaveGadClicked ( void );
  28.    *    static int PageBackwardGadClicked ( void );
  29.    *    static int PageForwardGadClicked ( void );
  30.    *    static int StartAdrGadClicked ( void );
  31.    *    static int HandleMemMonitorIDCMP ( void );
  32.    *
  33.    * Bemerkungen:
  34.    *    Speichermonitor von RSys. Wird verwendet, wenn keine
  35.    *    Modifikation von Objekten möglich ist.
  36.    *
  37.    * Erstellungsdatum:
  38.    *    29-Jul-93    Rolf Böhme
  39.    *
  40.    * Änderungen:
  41.    *    29-Jul-93    Rolf Böhme    Erstellung
  42.    *
  43.    ***************************************************************************
  44.  */
  45.  
  46. #include "RSys.h"
  47. #include "protos.h"
  48.  
  49.  
  50. static int DisplayCYGadClicked (void);
  51. static int SaveCGadClicked (void);
  52. static int ASCIIGadClicked (void);
  53. static int SaveHexGadClicked (void);
  54. static int SaveGadClicked (void);
  55. static int PageBackwardGadClicked (void);
  56. static int PageForwardGadClicked (void);
  57. static int StartAdrGadClicked (void);
  58.  
  59. static WINDOW *MemMonitorWnd = NULL;
  60. static GADGET *MemMonitorGList = NULL;
  61. INTUIMESSAGE MemMonitorMsg;
  62. static GADGET *MemMonitorGadgets[13];
  63. static UWORD MemMonitorLeft = 37;
  64. static UWORD MemMonitorTop = 14;
  65. static UWORD MemMonitorWidth = 616;
  66. static UWORD MemMonitorHeight = 217;
  67. static UBYTE *MemMonitorWdt = (UBYTE *) NAME " - Monitor";
  68.  
  69. static UBYTE *DisplayCYGad0Labels[] =
  70. {
  71.   (UBYTE *) "Hex/ASCII",
  72.   (UBYTE *) "Hex",
  73.   (UBYTE *) "ASCII",
  74.   NULL};
  75.  
  76. static char *headerline[3] =
  77. {
  78.   "     00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 0123456789ABCDEF",
  79.   "     00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F",
  80.   "     0123456789ABCDEF"
  81. };
  82.  
  83. static enum displaytypes
  84.   {
  85.     DT_hexascii, DT_hex, DT_ascii
  86.   };
  87.  
  88. static int CurrentDisplayType = DT_hexascii;
  89. static char Head[BUFSIZE];
  90.  
  91. static LIST DisplayLists[DISPLAYCOUNT];
  92. static NODE DisplayNodes[DISPLAYCOUNT][LINECOUNT];
  93.  
  94. static union
  95.   {
  96.     char memblock[BLOCKSIZE];
  97.     char memparts[LINECOUNT][LINESIZE];
  98.     ULONG memlongs[LINECOUNT][LINESIZE / sizeof (ULONG)];
  99.   }
  100. MemoryBlock;
  101.  
  102. static ULONG CurrentAddress, FirstAddress;
  103.  
  104. static REMEMBER *MonKey = NULL;
  105.  
  106. static UWORD MemMonitorGTypes[] =
  107. {
  108.   LISTVIEW_KIND,
  109.   CYCLE_KIND,
  110.   BUTTON_KIND,
  111.   BUTTON_KIND,
  112.   BUTTON_KIND,
  113.   BUTTON_KIND,
  114.   BUTTON_KIND,
  115.   BUTTON_KIND,
  116.   TEXT_KIND,
  117.   TEXT_KIND,
  118.   BUTTON_KIND,
  119.   TEXT_KIND,
  120.   TEXT_KIND
  121. };
  122.  
  123. static NEWGADGET MemMonitorNGad[] =
  124. {
  125.   12, 50, 589, 136, NULL, NULL, GD_MemoryLVGad, 0, NULL, NULL,
  126.   476, 19, 125, 13, (UBYTE *) "Display", NULL, GD_DisplayCYGad, PLACETEXT_LEFT, NULL, (APTR) DisplayCYGadClicked,
  127.   12, 201, 142, 13, (UBYTE *) "Save C-Code", NULL, GD_SaveCGad, PLACETEXT_IN, NULL, (APTR) SaveCGadClicked,
  128.   161, 201, 142, 13, (UBYTE *) "Save ASCII", NULL, GD_ASCIIGad, PLACETEXT_IN, NULL, (APTR) ASCIIGadClicked,
  129.   310, 201, 142, 13, (UBYTE *) "Save Hex", NULL, GD_SaveHexGad, PLACETEXT_IN, NULL, (APTR) SaveHexGadClicked,
  130.   459, 201, 142, 13, (UBYTE *) "Save as is", NULL, GD_SaveAsIsGad, PLACETEXT_IN, NULL, (APTR) SaveGadClicked,
  131.   12, 186, 193, 13, (UBYTE *) "<<< Prev 512 Bytes", NULL, GD_PageBackwardGad, PLACETEXT_IN, NULL, (APTR) PageBackwardGadClicked,
  132.   408, 186, 193, 13, (UBYTE *) "Next 512 Bytes >>>", NULL, GD_PageForwardGad, PLACETEXT_IN, NULL, (APTR) PageForwardGadClicked,
  133.   232, 19, 89, 13, (UBYTE *) "Current", NULL, GD_AddressTGad, PLACETEXT_LEFT, NULL, NULL,
  134.   64, 19, 89, 13, (UBYTE *) "Start", NULL, GD_StartAdrTGad, PLACETEXT_LEFT, NULL, NULL,
  135.   210, 186, 193, 13, (UBYTE *) "To start address", NULL, GD_StartAdrGad, PLACETEXT_IN, NULL, (APTR) StartAdrGadClicked,
  136.   64, 4, 537, 13, (UBYTE *) "Entry", NULL, GD_EntryInfo, PLACETEXT_LEFT, NULL, NULL,
  137.   12, 36, 589, 13, (UBYTE *) NULL, NULL, GD_HeaderLine, PLACETEXT_LEFT, NULL, NULL
  138. };
  139.  
  140. static ULONG *MemMonitorGTags[] =
  141. {
  142.   (ULONG *) (GTLV_ReadOnly), (ULONG *) TRUE, (ULONG *) (TAG_DONE),
  143.   (ULONG *) (GTCY_Labels), (ULONG *) & DisplayCYGad0Labels[0], (ULONG *) (TAG_DONE),
  144.   (ULONG *) (TAG_DONE),
  145.   (ULONG *) (TAG_DONE),
  146.   (ULONG *) (TAG_DONE),
  147.   (ULONG *) (TAG_DONE),
  148.   (ULONG *) (TAG_DONE),
  149.   (ULONG *) (TAG_DONE),
  150.   (ULONG *) (GTTX_Border), (ULONG *) TRUE, (ULONG *) (TAG_DONE),
  151.   (ULONG *) (GTTX_Border), (ULONG *) TRUE, (ULONG *) (TAG_DONE),
  152.   (ULONG *) (TAG_DONE),
  153.   (ULONG *) (GTTX_Border), (ULONG *) TRUE, (ULONG *) (TAG_DONE),
  154.   (ULONG *) (GTTX_Border), (ULONG *) TRUE, (ULONG *) (TAG_DONE),
  155. };
  156.  
  157. static int
  158. OpenMemMonitorWindow (void)
  159. {
  160.   NEWGADGET ng;
  161.   GADGET *g;
  162.   UWORD lc, tc;
  163.   UWORD wleft = MemMonitorLeft, wtop = MemMonitorTop, ww, wh;
  164.   int gl[] =
  165.   {GD_MemoryLVGad - GD_MemoryLVGad, GD_AddressTGad - GD_MemoryLVGad,
  166.    GD_StartAdrTGad - GD_MemoryLVGad, GD_EntryInfo - GD_MemoryLVGad,
  167.    GD_HeaderLine - GD_MemoryLVGad};
  168.  
  169.   AdjustWindowDimensions (Scr, MemMonitorLeft, MemMonitorTop,
  170.               MemMonitorWidth, MemMonitorHeight,
  171.               &wleft, &wtop, &ww, &wh);
  172.  
  173.   if (!(g = CreateContext (&MemMonitorGList)))
  174.     return (1L);
  175.  
  176.   for (lc = 0, tc = 0; lc < MemMonitor_CNT; lc++)
  177.     {
  178.  
  179.       CopyMem ((char *) &MemMonitorNGad[lc], (char *) &ng,
  180.            (long) sizeof (NEWGADGET));
  181.  
  182.       ng.ng_VisualInfo = VisualInfo;
  183.       ng.ng_TextAttr = Font;
  184.       ng.ng_LeftEdge = OffX + ComputeX (ng.ng_LeftEdge);
  185.       ng.ng_TopEdge = OffY + ComputeY (ng.ng_TopEdge);
  186.       ng.ng_Width = ComputeX (ng.ng_Width);
  187.       ng.ng_Height = ComputeY (ng.ng_Height);
  188.  
  189.       MemMonitorGadgets[lc] = g = CreateGadgetA ((ULONG) MemMonitorGTypes[lc], g, &ng, (TAGITEM *) & MemMonitorGTags[tc]);
  190.  
  191.       while (MemMonitorGTags[tc])
  192.     tc += 2;
  193.       tc++;
  194.  
  195.       if (NOT g)
  196.     return (2L);
  197.     }
  198.  
  199.   if (!(MemMonitorWnd = OpenWindowTags (NULL,
  200.                     WA_Left, wleft,
  201.                     WA_Top, wtop,
  202.                     WA_Width, ww,
  203.                     WA_Height, wh,
  204.                     WA_IDCMP, LISTVIEWIDCMP |
  205.                     CYCLEIDCMP | BUTTONIDCMP |
  206.                     TEXTIDCMP | IDCMP_CLOSEWINDOW |
  207.                     IDCMP_REFRESHWINDOW |
  208.                     IDCMP_VANILLAKEY,
  209.                     WA_Flags, WFLG_DRAGBAR |
  210.                     WFLG_DEPTHGADGET |
  211.                     WFLG_CLOSEGADGET |
  212.                     WFLG_SMART_REFRESH |
  213.                     WFLG_RMBTRAP,
  214.                     WA_Title, MemMonitorWdt,
  215.                     WA_PubScreenFallBack, TRUE,
  216.                     WA_PubScreen, Scr,
  217.                     TAG_DONE)))
  218.     return (4L);
  219.  
  220.   RefreshRastPort (MemMonitorWnd, MemMonitorGadgets, gl, 5, FALSE, MemMonitorGList);
  221.  
  222.   return (0L);
  223. }
  224.  
  225. static void
  226. SetTextGadgets (void)
  227. {
  228.   char curraddr[10], addr[10];
  229.  
  230.   sprintf (curraddr, "%08lX", CurrentAddress);
  231.   sprintf (addr, "%08lX", FirstAddress);
  232.  
  233.   GT_SetGadgetAttrs (MemMonitorGadgets[GD_AddressTGad - GD_MemoryLVGad], MemMonitorWnd,
  234.              NULL,
  235.              GTTX_Text, (UBYTE *) curraddr,
  236.              TAG_DONE);
  237.  
  238.   GT_SetGadgetAttrs (MemMonitorGadgets[GD_StartAdrTGad - GD_MemoryLVGad], MemMonitorWnd,
  239.              NULL,
  240.              GTTX_Text, (UBYTE *) addr,
  241.              TAG_DONE);
  242.  
  243.   GT_SetGadgetAttrs (MemMonitorGadgets[GD_HeaderLine - GD_MemoryLVGad], MemMonitorWnd,
  244.              NULL,
  245.              GTTX_Text, (UBYTE *) headerline[CurrentDisplayType],
  246.              TAG_DONE);
  247.  
  248.   return;
  249. }
  250.  
  251. static void
  252. SetListView (void)
  253. {
  254.   InitListView (MemMonitorWnd, MemMonitorGadgets[GD_MemoryLVGad - GD_MemoryLVGad],
  255.         &DisplayLists[CurrentDisplayType], UNSETLVPOS);
  256.  
  257.   return;
  258. }
  259.  
  260. static void
  261. ConvertLine (int type, int offset, char *memline, char *nodeline)
  262. {
  263.   char bytehex[LINESIZE][4], i, offsetstr[7], charline[LINESIZE + 1];
  264.  
  265.   for (i = 0; i < LINESIZE; i++)
  266.     {
  267.       sprintf (bytehex[i], "%02lX ", (unsigned char) memline[i]);
  268.       charline[i] = (isprint ((int) memline[i]) ? memline[i] : '.');
  269.     }
  270.  
  271.   charline[LINESIZE] = STRINGEND;
  272.  
  273.   sprintf (offsetstr, "%03lX: ", offset * 16);
  274.  
  275.   switch (type)
  276.     {
  277.     case DT_hexascii:
  278.       strncpy (nodeline, offsetstr, 5);
  279.       for (i = 0; i < LINESIZE; i++)
  280.     strncat (nodeline, bytehex[i], 4);
  281.       strncat (nodeline, charline, LINESIZE);
  282.       break;
  283.  
  284.     case DT_hex:
  285.       strncpy (nodeline, offsetstr, 5);
  286.       for (i = 0; i < LINESIZE; i++)
  287.     strncat (nodeline, bytehex[i], 4);
  288.       break;
  289.  
  290.     case DT_ascii:
  291.       strncpy (nodeline, offsetstr, 5);
  292.       strncat (nodeline, charline, LINESIZE);
  293.       break;
  294.     }
  295.  
  296.   return;
  297. }
  298.  
  299. static void
  300. FreeDisplayMemory (void)
  301. {
  302.   FreeRemember (MONKEY, TRUE);
  303.   return;
  304. }
  305.  
  306. static void
  307. ReInitDisplays (void)
  308. {
  309.   char memline[LINESIZE + 1];
  310.   char displaytype, j;
  311.  
  312.   SetTextGadgets ();
  313.  
  314.   Forbid ();
  315.   CopyMem ((APTR) CurrentAddress, (APTR) & MemoryBlock, BLOCKSIZE);
  316.   Permit ();
  317.  
  318.   for (displaytype = 0; displaytype < DISPLAYCOUNT; displaytype++)
  319.     {
  320.       NewList (&DisplayLists[displaytype]);
  321.  
  322.       for (j = 0; j < LINECOUNT; j++)
  323.     {
  324.       CopyMem (&MemoryBlock.memparts[j][0], &memline[0], LINESIZE);
  325.  
  326.       ConvertLine ((int) displaytype, (int) j, memline, DisplayNodes[displaytype][j].ln_Name);
  327.  
  328.       AddTail (&DisplayLists[displaytype], &DisplayNodes[displaytype][j]);
  329.     }
  330.     }
  331.  
  332.   SetListView ();
  333.  
  334.   return;
  335. }
  336.  
  337. static int
  338. InitDisplays (void)
  339. {
  340.   char memline[LINESIZE + 1];
  341.   char displaytype, j;
  342.  
  343.   SetTextGadgets ();
  344.  
  345.   Forbid ();
  346.   CopyMem ((APTR) CurrentAddress, (APTR) & MemoryBlock, BLOCKSIZE);
  347.   Permit ();
  348.  
  349.   for (displaytype = 0; displaytype < DISPLAYCOUNT; displaytype++)
  350.     {
  351.       NewList (&DisplayLists[displaytype]);
  352.  
  353.       for (j = 0; j < LINECOUNT; j++)
  354.     {
  355.       DisplayNodes[displaytype][j].ln_Name = AllocMonMem (3 * (LINESIZE + 9));
  356.  
  357.       if (!DisplayNodes[displaytype][j].ln_Name)
  358.         return FALSE;
  359.  
  360.       DisplayNodes[displaytype][j].ln_Type = NT_USER;
  361.       DisplayNodes[displaytype][j].ln_Pri = 0;
  362.  
  363.       CopyMem (&MemoryBlock.memparts[j][0], &memline[0], LINESIZE);
  364.  
  365.       ConvertLine ((int) displaytype, (int) j, memline, DisplayNodes[displaytype][j].ln_Name);
  366.  
  367.       AddTail (&DisplayLists[displaytype], &DisplayNodes[displaytype][j]);
  368.     }
  369.     }
  370.  
  371.   SetListView ();
  372.  
  373.   return TRUE;
  374. }
  375.  
  376. static void
  377. ReadNextBlock (void)
  378. {
  379.   if (CurrentAddress + 512L <= 0x01000000L)
  380.     CurrentAddress += 512L;
  381.   ReInitDisplays ();
  382.  
  383.   return;
  384. }
  385.  
  386. static void
  387. ReadPrevBlock (void)
  388. {
  389.   if (CurrentAddress - 512 >= 0)
  390.     CurrentAddress -= 512L;
  391.   ReInitDisplays ();
  392.  
  393.   return;
  394. }
  395.  
  396. static int
  397. DisplayCYGadClicked (void)
  398. {
  399.   CurrentDisplayType = MemMonitorMsg.Code;
  400.   SetListView ();
  401.  
  402.   return TRUE;
  403. }
  404.  
  405. static int
  406. SaveCGadClicked (void)
  407. {
  408.   /* routine when gadget "Save C-Code" is clicked. */
  409.   BPTR fout;
  410.   int i;
  411.  
  412.   sprintf (Head, "/\*\n   RSys-C-Code Generator"
  413.        "\n   Memory at 0x%08lX\n\*/\n\n", CurrentAddress);
  414.  
  415.   if (GetFile (MemMonitorWnd, "T:", "RSysData.c", "#?.c", "Save C-Code...", "Save"))
  416.     {
  417.       fout = AskFileMode ((char *) _fullpath, MemMonitorWnd);
  418.  
  419.       if (fout)
  420.     {
  421.       FPuts (fout, (STRPTR) Head);
  422.       FPuts (fout, (STRPTR) "ULONG RSysData[] = \{\n");
  423.  
  424.       for (i = 0; i < LINECOUNT; i++)
  425.         FPrintf (fout, (STRPTR) "   0x%08lX, 0x%08lX, 0x%08lX, 0x%08lX,\n",
  426.              MemoryBlock.memlongs[i][0],
  427.              MemoryBlock.memlongs[i][1],
  428.              MemoryBlock.memlongs[i][2],
  429.              MemoryBlock.memlongs[i][3]);
  430.  
  431.       FPuts (fout, (STRPTR) "\};\n/\* End of Code \*/\n");
  432.  
  433.       Close (fout);
  434.     }
  435.     }
  436.  
  437.   return TRUE;
  438. }
  439.  
  440. static int
  441. ASCIIGadClicked (void)
  442. {
  443.   /* routine when gadget "Save ASCII" is clicked. */
  444.   sprintf (Head, "Memory at 0x%08lX", CurrentAddress);
  445.  
  446.   if (GetFile (MemMonitorWnd, "T:", "RSysMemoryASCII.dat", "#?.dat",
  447.            "Save as ASCII-Data...", "Save"))
  448.     SaveList (MemMonitorWnd, (char *) _fullpath, Head,
  449.           &DisplayLists[DT_ascii], FALSE);
  450.  
  451.   return TRUE;
  452. }
  453.  
  454. static int
  455. SaveHexGadClicked (void)
  456. {
  457.   /* routine when gadget "Save Hex" is clicked. */
  458.  
  459.   sprintf (Head, "Memory at 0x%08lX", CurrentAddress);
  460.  
  461.   if (GetFile (MemMonitorWnd, "T:", "RSysMemoryHEX.dat", "#?.dat",
  462.            "Save as Hex-Datas...", "Save"))
  463.     SaveList (MemMonitorWnd, (char *) _fullpath, Head,
  464.           &DisplayLists[DT_hex], FALSE);
  465.   return TRUE;
  466. }
  467.  
  468. static int
  469. SaveGadClicked (void)
  470. {
  471.   /* routine when gadget "Save as is" is clicked. */
  472.  
  473.   sprintf (Head, "Memory at 0x%08lX", CurrentAddress);
  474.  
  475.   if (GetFile (MemMonitorWnd, "T:", "MemoryList.dat", "#?.dat",
  476.            "Save List as is...", "Save"))
  477.     SaveList (MemMonitorWnd, (char *) _fullpath, Head,
  478.           &DisplayLists[CurrentDisplayType], FALSE);
  479.  
  480.   return TRUE;
  481. }
  482.  
  483. static int
  484. PageBackwardGadClicked (void)
  485. {
  486.   /* routine when gadget "<<< Prev 512 Bytes" is clicked. */
  487.   ReadPrevBlock ();
  488.  
  489.   return TRUE;
  490. }
  491.  
  492. static int
  493. PageForwardGadClicked (void)
  494. {
  495.   /* routine when gadget "Next 512 Bytes >>>" is clicked. */
  496.   ReadNextBlock ();
  497.  
  498.   return TRUE;
  499. }
  500.  
  501. static int
  502. StartAdrGadClicked (void)
  503. {
  504.   CurrentAddress = FirstAddress;
  505.  
  506.   ReInitDisplays ();
  507.  
  508.   return TRUE;
  509. }
  510.  
  511. static int
  512. HandleMemMonitorIDCMP (void)
  513. {
  514.   INTUIMESSAGE *m;
  515.   int (*func) (void);
  516.   BOOL running = TRUE;
  517.  
  518.   while (m = GT_GetIMsg (MemMonitorWnd->UserPort))
  519.     {
  520.       CopyMem ((char *) m, (char *) &MemMonitorMsg,
  521.            (long) sizeof (INTUIMESSAGE));
  522.  
  523.       GT_ReplyIMsg (m);
  524.  
  525.       switch (MemMonitorMsg.Class)
  526.     {
  527.     case IDCMP_REFRESHWINDOW:
  528.       MakeWindowRefresh (MemMonitorWnd);
  529.       break;
  530.  
  531.     case IDCMP_CLOSEWINDOW:
  532.       running = FALSE;
  533.       break;
  534.  
  535.     case IDCMP_VANILLAKEY:
  536.       if (MemMonitorMsg.Code == ESC)
  537.         running = FALSE;
  538.       break;
  539.  
  540.     case IDCMP_GADGETUP:
  541.     case IDCMP_GADGETDOWN:
  542.       HandleHelp ((enum RSysNumber)
  543.               ((GADGET *) MemMonitorMsg.IAddress)->GadgetID);
  544.       func = (int (*)()) ((GADGET *) MemMonitorMsg.IAddress)->UserData;
  545.       running = func ();
  546.       break;
  547.     }
  548.     }
  549.   return (running);
  550. }
  551.  
  552. void
  553. Monitor (RSYS_Objid * obj, char *entrystring)
  554. {
  555.   RSYS_ValidMemoryNode *vmnode;
  556.   char header[2 * BUFSIZE];
  557.  
  558.   HandleHelp (MONITOR);
  559.  
  560.   CurrentDisplayType = DT_hexascii;
  561.  
  562.   CurrentAddress = (ULONG) obj->address;
  563.   FirstAddress = (ULONG) obj->address;
  564.  
  565.   vmnode = CheckNode (CurrentAddress);
  566.  
  567.   if (!vmnode)
  568.     ErrorHandle ("Address not found in table", MEMORY_ERR, TYPE_FAIL, NO_KILL);
  569.   else if (!IsValid (vmnode) && !MyEasyRequest (SysWnd, (STRPTR) NAME " - Memory validation info",
  570.                          (STRPTR) "Call Monitor|Cancel",
  571.     (STRPTR) "You requested a memory start address which is not valid\n"
  572.             "and can produce an Enforcer Hit! The Attributes are:\n"
  573.                         "%s \n%s \n%s\nComment: %s\n"
  574.              "Do you want to call the " NAME "-Monitor anyway?",
  575.                         "- Invalid",
  576.                         (IsWriteProtect (vmnode) ? "- Write protected" : "- Not write protected"),
  577.          (IsCacheable (vmnode) ? "- Cacheable" : "- Not cacheable"),
  578.                         vmnode->vm_comment))
  579.     return;
  580.  
  581.   if (OpenASysWindow (OpenMemMonitorWindow, NO_KILL))
  582.     {
  583.       LockMainWindow (WIN_LOCK);
  584.  
  585.       if (vmnode)
  586.     sprintf (header, "%s [%s]", &entrystring[9], vmnode->vm_comment);
  587.       else
  588.     sprintf (header, "%s [no valid memory info]", &entrystring[9]);
  589.  
  590.       GT_SetGadgetAttrs (MemMonitorGadgets[GD_EntryInfo - GD_MemoryLVGad], MemMonitorWnd,
  591.              NULL,
  592.              GTTX_Text, (UBYTE *) header,
  593.              TAG_DONE);
  594.  
  595.       if (InitDisplays ())
  596.     while (HandleMemMonitorIDCMP ());
  597.       else
  598.     ErrorHandle ("Display nodes", MEMORY_ERR, ALLOC_FAIL, NO_KILL);
  599.  
  600.       FreeDisplayMemory ();
  601.  
  602.       CloseASysWindow (&MemMonitorWnd, &MemMonitorGList, NULL);
  603.  
  604.       LockMainWindow (WIN_UNLOCK);
  605.     }
  606.  
  607.   return;
  608. }
  609.